﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
//给你一个由不同字符组成的字符串 allowed 和一个字符串数组 words 。
//如果一个字符串的每一个字符都在 allowed 中，就称这个字符串是 一致字符串 。
//请你返回 words 数组中 一致字符串 的数目。
//int countConsistentStrings(char* allowed, char** words, int wordsSize) 
//{
//	int arr1[26] = { 0 };
//	int amount = 0;
//	while (*allowed)
//	{
//		arr1[*allowed - 'a']++;
//		allowed++;
//	}
//	int i = 0;
//	for (i = 0; i < wordsSize; i++)
//	{
//		int arr2[26] = { 0 };
//		while (*(words[i]))
//		{
//			arr2[*(words[i]) - 'a']++;
//			words[i]++;
//		}
//		int j = 0;
//		for (j = 0; j < 26; j++)
//		{
//			if (arr1[j] != arr2[j] && arr2[j] != 0)
//				break;
//		}
//		if (j == 26)
//		{
//			amount++;
//		}
//	}
//	return amount;
//}
//int main()
//{
//	char p[][10] = {"ad","bd","aaab","baa","badab"};
//	char p1[] = "ab";
//	countConsistentStrings(p1, p, 5);
//	return 0;
//}

//char* mergeAlternately(char* word1, char* word2) {
//	int len1 = strlen(word1);
//	int len2 = strlen(word2);
//	char* ch = (char*)malloc(len1 + len2 + 1);
//	int i = 0;
//	while (*word1 && *word2)
//	{
//		ch[i++] = *word1;
//		ch[i++] = *word2;
//		word1++;
//		word2++;
//	}
//	if (*word1 == 0)
//	{
//		while (*word2)
//		{
//			ch[i++] = *word2;
//			word2++;
//		}
//	}
//	else
//	{
//		while (*word1)
//		{
//			ch[i++] = *word1;
//			word1++;
//		}
//	}
//	ch[i] = '\0';
//	return ch;
//}
//int main()
//{
//	char p1[] = "abc";
//	char p2[] = "def";
//	mergeAlternately(p1, p2);
//	return 0;
//}

//int test(char* p1, char* s2)//出错了
//{
//	char* p2 = p1;
//	char* p3 = s2;
//	while (1)
//	{
//		if (*p2 != *p3 || *p3 == '\0')
//		{
//			break;
//		}
//		else
//		{
//			p2++;
//			p3++;
//		}
//	}
//	return *p2 == '\0' ? 1 : 0;
//}
//字符串轮转。给定两个字符串s1和s2，
//请编写代码检查s2是否为s1旋转而成（比如，waterbottle是erbottlewat旋转后的字符串）。
//bool isFlipedString(char* s1, char* s2)
//{
//	int len1 = strlen(s1);
//	int len2 = strlen(s2);
//	if (len1 != len2)
//	{
//		return false;
//	}
//	else if (len1 == len2 && len1 == 0)
//	{
//		return true;
//	}
//	else
//	{
//		char* p1 = (char*)malloc(sizeof(char) * 2 * len1 + 1);
//		int i = 0;
//		while (len1)
//		{
//			p1[i] = s1[i];
//			i++;
//			len1--;
//		}
//		int j = 0;
//		while (len2)
//		{
//			p1[i] = s1[j];
//			i++;
//			j++;
//			len2--;
//		}
//		p1[i] = '\0';
//		if (strstr(p1, s2) != NULL)
//			return true;
//	}
//	return false;
//}
//int main()
//{
//	char p1[] = "waterbottle";
//	char p2[] = "terbottlewa";
//	isFlipedString(p1, p2);
//	return 0;
//}

//给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
//请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
//注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。
//为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
//int cmpfunc(void* a, void* b)
//{
//	return (*(int*)a - *(int*)b);
//}
//
//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) //第一种方法.
// 
//	int i = 0;
//	while (n)
//	{
//		nums1[m + i] = nums2[i];
//		i++;
//		n--;
//	}
//	qsort(nums1, nums1Size, sizeof(int), cmpfunc);
//}
//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)//第二种方法。
//{
//	int i = 1;
//	int x = m-i;
//	int y = n-i;
//	if (n == 0)
//		;
//	else if (m == 0)
//	{
//		for (i = 0; i < n; i++)
//		{
//			nums1[i] = nums2[i];
//		}
//	}
//	else
//	{
//		int i = 0;
//		while (n && m)
//		{
//			if (nums1[x] > nums2[y])
//			{
//				nums1[nums1Size - i - 1] = nums1[x];
//				x--;
//				m--;
//			}
//			else
//			{
//				nums1[nums1Size - i - 1] = nums2[y];
//				y--;
//				n--;
//			}
//			i++;
//		}
//		if (m == 0)
//		{
//			i = 0;
//			for (i = 0; i < n; i++)
//			{
//				nums1[i] = nums2[i];
//			}
//		}
//	}
//}
//int main()
//{
//	int arr1[6] = { 4,5,6 };
//	int arr2[3] = { 1,2,3 };
//	int sz1 = sizeof(arr1) / sizeof(arr1[0]);
//	int sz2 = sizeof(arr2) / sizeof(arr2[0]);
//	merge(arr1, sz1, 3, arr2, sz2, sz2);
//	int i = 0;
//	for (i = 0; i < sz1; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//	return 0;
//}

//错误

//和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。
//现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。
//数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。
// 这里可以跑的动，力扣跑不动
//int cmpfunc(void* a,void* b)
//{
//	return (*(int*)a - *(int*)b);
//}
//
//int findLHS(int* nums, int numsSize)
//{
//	qsort(nums, numsSize, sizeof(int), cmpfunc);
//	if (nums[0] == nums[numsSize - 1])
//	{
//		return 0;
//	}
//	int i = 0;
//	int amount = 0;
//	for (i = 0; i < numsSize; i++)
//	{
//		int min = nums[i];
//		int flag = 0;
//		int n = i;
//		min = nums[i];
//		while (nums[i] - min < 2 && i < numsSize)
//		{
//			flag++;
//			i++;
//		}
//		if (nums[i-1] - min == 0)
//		{
//			flag = 0;
//		}
//		if (flag > amount)
//		{
//			amount = flag;
//		}
//		i = n;
//		if (amount > numsSize - n - 1)
//		{
//			break;
//		}
//	}
//	return amount;
//}
//int main()
//{
//	int nums[] = { 1,3,2,2,5,2,3,7 };
//	int sz = sizeof(nums) / sizeof(nums[0]);
//	int ret = findLHS(nums, sz);
//	printf("%d ", ret);
//	return 0;
//}
//

//超市正在促销，你可以用 numExchange 个空水瓶从超市兑换一瓶水。最开始，你一共购入了 numBottles 瓶水。
//如果喝掉了水瓶中的水，那么水瓶就会变成空的。
//给你两个整数 numBottles 和 numExchange ，返回你 最多 可以喝到多少瓶水。
//
//int numWaterBottles(int numBottles, int numExchange) {
//	int amount = numBottles;
//	int bottle1 = amount;
//	int bottle2 = amount;
//	while (1)
//	{
//		amount += bottle1 / numExchange;
//		bottle2 = bottle1 % numExchange + bottle1 / numExchange;
//		bottle1 = bottle2;
//		if (bottle1 < numExchange)
//			break;
//	}
//	return amount;
//}

//如果两个字符串 word1 和 word2 中从 'a' 到 'z' 每一个字母出现频率之差都 不超过 3 ，那么我们称这两个字符串 word1 和 word2 几乎相等 。
//给你两个长度都为 n 的字符串 word1 和 word2 ，如果 word1 和 word2 几乎相等 ，请你返回 true ，否则返回 false 。
//一个字母 x 的出现 频率 指的是它在字符串中出现的次数。
//旧题新做
//bool checkAlmostEquivalent(char* word1, char* word2)
//{
//	int arr1[26] = { 0 };
//	int arr2[26] = { 0 };
//	while (*word1)
//	{
//		arr1[*word1 - 'a']++;
//		word1++;
//	}
//	while (*word2)
//	{
//		arr2[*word2 - 'a']++;
//		word2++;
//	}
//	int i = 0;
//	for (i = 0; i < 26; i++)
//	{
//		if (abs(arr1[i] - arr2[i]) > 3)
//		{
//			return false;
//		}
//	}
//	return true;
//}

//旧题新做
//int cmpfunc(void* a, void* b)
//{
//	return (*(int*)a - *(int*)b);
//}
//
//int findSpecialInteger(int* arr, int arrSize)
//{
//	qsort(arr, arrSize, sizeof(int), cmpfunc);
//	int i = 0;
//	int n = 0;
//	for (i = 0; i < arrSize-1; i++)
//	{
//		if (arr[i] == arr[i + 1])
//		{
//			n++;
//		}
//		else
//		{
//			if (n >= arrSize / 4)
//			{
//				break;
//			}
//			else
//			{
//				n = 0;
//			}
//		}
//	}
//	return arr[i];
//}
//int main()
//{
//	int arr[] = { 1,1,1,1,1,1,2,3,4,5,6,7,8,9,10,11,12,12,12,12 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int ret = findSpecialInteger(arr, sz);
//	printf("%d", ret);
//	return 0;
//}

//给你一个整数数组 arr，请你检查是否存在两个整数 N 和 M，满足 N 是 M 的两倍（即，N = 2 * M）。
//更正式地，检查是否存在两个下标 i 和 j 满足：
//旧题新做
//bool checkIfExist(int* arr, int arrSize)
//{
//	int i = 0;
//	int flag = 0;
//	for (i = 0; i < arrSize; i++)
//	{
//		int j = 0;
//		if (arr[i] == 0)
//		{
//			continue;
//			flag++;
//		}
//		for (j = i; j < arrSize; j++)
//		{
//			if (i == j || arr[j] == 0)
//			{
//				continue;
//			}
//			if ((arr[i] % arr[j] == 0 && arr[i] / arr[j] == 2) || (arr[j] % arr[i] == 0 && arr[j] / arr[i] == 2))
//			{
//				return true;
//			}
//		}
//	}
//	if (flag > 1)
//	{
//		return true;
//	}
//	return false;
//}
//int main()
//{
//	int arr[] = { 0,0};
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	checkIfExist(arr, sz);
//	return 0;
//}

//void reverseString(char* s, int sSize) {
//	int i = 0;
//	int left = 0;
//	int right = sSize - 1;
//	while (left < right)
//	{
//		char tmp = s[left];
//		s[left] = s[right];
//		s[right] = tmp;
//		left++;
//		right--;
//	}
//}

//int test(char s, char* p)
//{
//	int i = 0;
//	for (i = 0; i <= 10; i++)
//	{
//		if (s == p[i])
//			return 1;
//	}
//	return 0;
//}
//
//char* reverseVowels(char* s) {
//	char p[11] = "aoeiuAEIOU";
//	int right = strlen(s) - 1;
//	int left = 0;
//	while (left < right)
//	{
//		if (test(s[left], p) != 1)
//		{
//			left++;
//			continue;
//		}
//		if (test(s[right], p) != 1)
//		{
//			right--;
//			continue;
//		}
//		char tmp = s[left];
//		s[left] = s[right];
//		s[right] = tmp;
//		right--;
//		left++;
//	}
//	return s;
//}

int findLengthOfLCIS(int* nums, int numsSize) {
	int flag = 0;
	int i = 0;
	int max = 0;
	for (i = 0; i < numsSize-1; i++)
	{
		if (nums[i] < nums[i + 1])
		{
			flag++;
		}
		else
		{
			if (max == 0)
			{
				max = flag;
			}
			if (max < flag)
			{
				max = flag;
			}
			flag = 0;
		}
	}
	if (flag == 0)
		return 1;
	return flag;
}
int main()
{
	int arr[] = { 1,3,5,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	findLengthOfLCIS(arr, sz);
	return 0;
}